package main

// import (
// 	"crypto/tls"
// 	"encoding/binary"
// 	"flag"
// 	"fmt"
// 	"io"
// 	"log"
// 	"net"
// 	"net/url"
// 	"strconv"
// 	"strings"
// 	"time"
// )

// // 代理配置
// type ProxyConfig struct {
// 	Type     string // "trojan"
// 	Server   string // IP or domain
// 	Port     int
// 	Pass     string // Password for Trojan
// 	Security string // TLS settings
// 	Peer     string // SNI for TLS
// }

// // 解析Trojan链接
// func parseTrojanLink(link string) (*ProxyConfig, error) {
// 	u, err := url.Parse(link)
// 	if err != nil {
// 		return nil, err
// 	}

// 	if u.Scheme != "trojan" {
// 		return nil, fmt.Errorf("unsupported scheme: %s", u.Scheme)
// 	}

// 	pass, _ := u.User.Password()
// 	if pass == "" {
// 		pass = u.User.Username()
// 	}

// 	host := u.Hostname()
// 	portStr := u.Port()

// 	config := &ProxyConfig{
// 		Type:   "trojan",
// 		Server: host,
// 		Port:   443, // 默认端口是443
// 		Pass:   pass,
// 		Peer:   host, // 默认使用服务器地址作为SNI
// 	}

// 	if portStr != "" {
// 		config.Port, err = strconv.Atoi(portStr)
// 		if err != nil {
// 			return nil, err
// 		}
// 	}

// 	// 解析查询参数
// 	query := u.Query()
// 	if insecure := query.Get("allowInsecure"); insecure == "1" || strings.ToLower(insecure) == "true" {
// 		config.Security = "insecure-tls"
// 	} else {
// 		config.Security = "tls"
// 	}

// 	if peer := query.Get("peer"); peer != "" {
// 		config.Peer = peer
// 	}

// 	return config, nil
// }

// // 实现SOCKS5代理服务器
// func StartSOCKS5Server(listenAddr string, trojanConfig *ProxyConfig) error {
// 	listener, err := net.Listen("tcp", listenAddr)
// 	if err != nil {
// 		return err
// 	}

// 	log.Printf("Starting SOCKS5 proxy on %s", listenAddr)

// 	for {
// 		clientConn, err := listener.Accept()
// 		if err != nil {
// 			log.Printf("Error accepting connection: %v", err)
// 			continue
// 		}

// 		// 为每个连接创建一个goroutine处理
// 		go handleClient(clientConn, trojanConfig)
// 	}
// }

// // 处理客户端连接
// func handleClient(clientConn net.Conn, trojanConfig *ProxyConfig) {
// 	defer clientConn.Close()

// 	// 设置超时
// 	clientConn.SetDeadline(time.Now().Add(30 * time.Second))

// 	// 1. 处理SOCKS5握手
// 	buf := make([]byte, 256)

// 	// 读取版本和认证方法数量
// 	n, err := clientConn.Read(buf)
// 	if err != nil {
// 		log.Printf("Error reading SOCKS5 handshake: %v", err)
// 		return
// 	}

// 	if n < 2 || buf[0] != 0x05 {
// 		log.Printf("Unsupported SOCKS version: %02x", buf[0])
// 		return
// 	}

// 	// 回复支持的认证方法 (0x00 = 无需认证)
// 	clientConn.Write([]byte{0x05, 0x00})

// 	// 2. 读取客户端请求
// 	n, err = clientConn.Read(buf)
// 	if err != nil {
// 		log.Printf("Error reading SOCKS5 request: %v", err)
// 		return
// 	}

// 	if n < 5 || buf[0] != 0x05 {
// 		log.Printf("Invalid SOCKS5 request: %v", buf[:n])
// 		return
// 	}

// 	cmd := buf[1]      // 命令 (0x01 = CONNECT)
// 	addrType := buf[3] // 地址类型

// 	// 解析目标地址
// 	var targetAddr string
// 	var targetPort int

// 	switch addrType {
// 	case 0x01: // IPv4
// 		if n < 10 {
// 			log.Printf("Invalid IPv4 address length")
// 			return
// 		}
// 		ip := net.IPv4(buf[4], buf[5], buf[6], buf[7])
// 		port := binary.BigEndian.Uint16(buf[8:10])
// 		targetAddr = ip.String()
// 		targetPort = int(port)

// 	case 0x03: // 域名
// 		domainLen := int(buf[4])
// 		if n < 5+domainLen+2 {
// 			log.Printf("Invalid domain address length")
// 			return
// 		}
// 		domain := string(buf[5 : 5+domainLen])
// 		port := binary.BigEndian.Uint16(buf[5+domainLen : 5+domainLen+2])
// 		targetAddr = domain
// 		targetPort = int(port)

// 	case 0x04: // IPv6
// 		if n < 22 {
// 			log.Printf("Invalid IPv6 address length")
// 			return
// 		}
// 		ip := net.IP(buf[4:20])
// 		port := binary.BigEndian.Uint16(buf[20:22])
// 		targetAddr = ip.String()
// 		targetPort = int(port)

// 	default:
// 		log.Printf("Unsupported address type: %02x", addrType)
// 		clientConn.Write([]byte{0x05, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
// 		return
// 	}

// 	// 检查命令类型
// 	if cmd != 0x01 { // 只支持CONNECT命令
// 		log.Printf("Unsupported command: %02x", cmd)
// 		clientConn.Write([]byte{0x05, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
// 		return
// 	}

// 	// 构建完整的目标地址
// 	target := fmt.Sprintf("%s:%d", targetAddr, targetPort)
// 	log.Printf("Connecting to %s via Trojan", target)

// 	// 3. 连接到Trojan服务器
// 	trojanConn, err := connectTrojan(trojanConfig, target)
// 	if err != nil {
// 		log.Printf("Error connecting to Trojan server: %v", err)
// 		clientConn.Write([]byte{0x05, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
// 		return
// 	}

// 	defer trojanConn.Close()

// 	// 4. 发送成功响应给客户端
// 	clientConn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})

// 	// 5. 开始双向数据转发
// 	clientConn.SetDeadline(time.Time{}) // 取消超时
// 	trojanConn.SetDeadline(time.Time{})

// 	go func() {
// 		io.Copy(trojanConn, clientConn)
// 		trojanConn.(*tls.Conn).CloseWrite() // 关闭写入端，但保持读取
// 	}()

// 	io.Copy(clientConn, trojanConn)
// }

// // 连接到Trojan服务器
// func connectTrojan(config *ProxyConfig, target string) (net.Conn, error) {
// 	// 解析目标地址
// 	host, portStr, err := net.SplitHostPort(target)
// 	if err != nil {
// 		return nil, err
// 	}

// 	port, err := strconv.Atoi(portStr)
// 	if err != nil {
// 		return nil, err
// 	}

// 	// 配置TLS
// 	tlsConfig := &tls.Config{
// 		ServerName: config.Peer,
// 	}

// 	if config.Security == "insecure-tls" {
// 		tlsConfig.InsecureSkipVerify = true
// 	}

// 	// 连接到Trojan服务器
// 	trojanAddr := fmt.Sprintf("%s:%d", config.Server, config.Port)
// 	conn, err := tls.Dial("tcp", trojanAddr, tlsConfig)
// 	if err != nil {
// 		return nil, fmt.Errorf("failed to connect to Trojan server: %w", err)
// 	}

// 	// 构建Trojan请求
// 	var request []byte

// 	// 添加密码
// 	request = append(request, []byte(config.Pass)...)

// 	// 添加CRLF
// 	request = append(request, '\r', '\n')

// 	// 添加CMD (CONNECT)
// 	request = append(request, 0x01)

// 	// 添加目标地址
// 	var addrBytes []byte
// 	var atyp byte

// 	// 判断地址类型
// 	if ip := net.ParseIP(host); ip != nil {
// 		if ip4 := ip.To4(); ip4 != nil {
// 			atyp = 0x01 // IPv4
// 			addrBytes = ip4
// 		} else {
// 			atyp = 0x04 // IPv6
// 			addrBytes = ip
// 		}
// 	} else {
// 		atyp = 0x03 // DOMAINNAME
// 		addrBytes = append([]byte{byte(len(host))}, []byte(host)...)
// 	}

// 	// 添加地址类型
// 	request = append(request, atyp)

// 	// 添加地址数据
// 	request = append(request, addrBytes...)

// 	// 添加端口号(大端序)
// 	portBytes := make([]byte, 2)
// 	binary.BigEndian.PutUint16(portBytes, uint16(port))
// 	request = append(request, portBytes...)

// 	// 添加CRLF
// 	request = append(request, '\r', '\n')

// 	// 打印请求
// 	log.Printf("Sending Trojan request: %q", request)

// 	// 发送请求
// 	_, err = conn.Write(request)
// 	if err != nil {
// 		conn.Close()
// 		return nil, fmt.Errorf("failed to send Trojan request: %w", err)
// 	}

// 	// 读取Trojan响应 (通常为空)
// 	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
// 	buf := make([]byte, 1024)
// 	n, err := conn.Read(buf)

// 	if err != nil && err != io.EOF && !strings.Contains(err.Error(), "i/o timeout") {
// 		conn.Close()
// 		return nil, fmt.Errorf("failed to read Trojan response: %w", err)
// 	}

// 	// 重置读取超时
// 	conn.SetReadDeadline(time.Time{})

// 	// 打印响应 (通常为空)
// 	if n > 0 {
// 		log.Printf("Trojan response: %q", buf[:n])
// 	}

// 	return conn, nil
// }

// func main() {
// 	link := flag.String("u", "", "Trojan link (required)")
// 	listenAddr := flag.String("l", "127.0.0.1:1080", "Local listen address")
// 	flag.Parse()

// 	if *link == "" {
// 		log.Fatal("Please provide a Trojan link using -u option.")
// 	}

// 	config, err := parseTrojanLink(*link)
// 	if err != nil {
// 		log.Fatalf("Error parsing Trojan link: %v", err)
// 	}

// 	log.Printf("Trojan proxy configuration:")
// 	log.Printf("  Server: %s:%d", config.Server, config.Port)
// 	log.Printf("  Security: %s", config.Security)
// 	log.Printf("  Peer: %s", config.Peer)

// 	err = StartSOCKS5Server(*listenAddr, config)
// 	if err != nil {
// 		log.Fatalf("Failed to start SOCKS5 server: %v", err)
// 	}
// }
